class AI
{
	int depth;
	Stack nodes[];
	Gameboard current_state;
	
	evaluate_value();	//uses nodes defined above to give value defined in stack
	find_children(Gameboard board);	//this will take in the gameboard from the engine and store the children in stack nodes
									//it will calculate the positions available and in each node it will store this in value
	number_of_available_moves(Gameboard board);	//only called when depth = 2
}


/********
	if depth = 0, find all children and call find children for each of them depth++

	if depth = 1, find all children and store in Stack nodes[]
				  calculate a number of available moves for each child
				  find the max and the min and store in Stack nodes[] to each respective child

********/

class Stack
{
	int value;
	int max_value_node;
	int min_value_node;
	Stack nodes[];
	int current_player;	//could be bool
}

/*
	basically the first value will go to the AI (the current state of the game)
	
*/


/*********************************************************************************************
	JOHN'S RAMBLING IDEAS THAT MIGHT NOT MAKE SENSE OR WORK
*********************************************************************************************/

/******************************************
	a recursive function that with each 
	invocation decreases "depth" until 0 
	so it will stop without scanning the 
	entire game board choices
*******************************************/
short chooseMove(bool side, short depth)
{
	//stuff ...
	
	if(current board is full || no moves left || depth = 3)
	{
		if(Best::score  < count_num_moves() && side != true)
		{
			for(int j = 0; j < depth; i++)
			{
				// for the undo function undo()
			}
		}
		return bestmove;
	}
	else{
	//stuff ...
	
	chooseMove(!side, ++depth); //somewhere in this funciton it will be called with the opposite side and depth decreased
	}
	
	return mybest;
}



class Best
{
	Best(Gameboard board);
	
	/********
	   MOVE
	 *******/
	int row;
	int column;
	int score;
	
	
	
	short chooseMove(boolean black, int depth);
}


return board.numStars();

public Best chooseMove(boolean side)
{
	Best mybest = new Best();	//My best move
	Best reply;					//Opponent's best reply
	
	if(the current grid is full or has a win)
	{
		return a Best witht he Grid's score, no move;
	}
	
	if(side == COMPUTER)
	{
		myBest.score = -2;
	}
	else
	{
		myBest.score = 2;
	}
	
	for(each legal move m)
	{
		perform move m;		//Modifies "this" grid
		reply = chooseMove(!side);
		undo move m;		//Restores "this" grid
		
		if(((side == COMPUTER) && (reply.score > myBest.score)) ||
			((side == HUMAN) && (reply.score < myBest.score)))
		{
			myBest.move = m;
			myBest.score = reply.score;
		}
	}
	return myBest;
}

/*********************************************************************************************
	Powell'S RAMBLING IDEAS THAT MIGHT NOT MAKE SENSE OR WORK
*********************************************************************************************/

/******************************************
	a recursive function that with each 
	invocation decreases "depth" until 0 
	so it will stop without scanning the 
	entire game board choices
*******************************************/
/*
	










